const storageService = require('../../../services/storage')
const lightCommonService = require('../../../services/light_common_service')
const shortcutModeService = require('../../../services/shortcut_mode_service')
const playerModeService = require('../../../services/player_mode_service')
const advancedModeService = require('../../../services/advanced_mode_service')

const appInstance = getApp();

const modeNum = 7

Page({
  data: {
    device: null, // 存储设备或编组信息
    isGroup: false, // 标记是设备还是编组
    showTimerPopup: false,
    timerTasks: [],
    modeOptions: [], // 预设模式名称列表
    showDeleteConfirm: false,
    deleteTaskIndex: -1,
    showTimeConflictConfirm: false, // 时间冲突提醒弹窗
    showCrossZeroConfirm: false, // 跨0点确认弹窗
    crossZeroModeEnabled: false, // 跨0点模式开关状态
    timeConflictMessage: '', // 时间冲突错误消息
    showFirstVisitTip: false, // 首次访问提示弹窗
    isManualMode: false, // 手动模式状态
    sliderContainerClass: '', // 滑块容器样式类，根据通道数量动态调整
    presets: [
      /*{
              id: 1,
              name: '自定义1',
              selected: true,
              channels:[{n:'W',u:1,v:0,nm:'',c:''}]
            },*/
    ],
    isLumiChange: true,
    autoTimeout: 0,
    quickChangePalleteFlag: false,
    preset_list: [],
    user_preset_list: [],
    preset_index: 0,

    forceRefresh: false, // 触发强制刷新的标志

    did: null,
    device: null,
    switchType: 0, //1=手动切自动(废弃)；2=自动切手动；3=启用行程；4=禁用行程；5=禁用行程切手动
    tmpEnabled: false,
    tmpIndex: -1,
    channels: [],
    mqttData: null,

    isGroup: false,
    devices: [],
    syncNum: 0,
  },
  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log(options);
    this.setData({
      did: options.did
    });

    let isGroup = false
    let dobj = storageService.getDeviceInfo(options.did)
    this.data.device = dobj;
    if (dobj.deviceId.startsWith('group_')) {
      isGroup = true
      const devices = storageService.batchGetDeviceInfo(dobj.deviceIds)
      this.data.devices = [...devices]
    }

    let entityId = this.data.did
    const deviceType = this.data.device.deviceType

    const playerData = storageService.getPlayerModeData(entityId, isGroup, deviceType);
    console.log("playerData", playerData)

    const currentPresets = playerModeService.initializePresets(entityId, playerData.presets)

    // 初始化页面显示状态
    this._isPageShowing = true;
    // 获取灯光模式状态
    const lightModeState = storageService.getLightModeState(entityId)
    const isManual = lightModeState === 'manual'

    if (isManual) {
      const selectedPreset = currentPresets.find(p => p.selected);
      if (selectedPreset) {
        // 在进入页面时立即发送MQTT消息，确保设备接收到当前预设的灯光值
        console.log('玩家模式页面加载时发送初始MQTT消息');
        this.sendRgbwMqttMessage(selectedPreset, deviceType);
      }
    }

    // 获取玩家模式预设选项 - 只包含玩家模式预设，不包括快捷模式
    const playerModeOptions = this.getPlayerModeOptions(currentPresets);

    // 生成模式选择器选项
    const modeOptions = []

    const smodeOptions = shortcutModeService.getModeNames(this.data.device.deviceType)
    const pmodeOptions = playerModeService.getModeNames(entityId)
    modeOptions.push(...smodeOptions)
    modeOptions.push(...pmodeOptions)

    // 合并初始数据设置
    const initialData = {
      isManualMode: isManual,
      presets: currentPresets,
      playerModeOptions: playerModeOptions, // 保存玩家模式选项数据，供后续使用
      modeOptions: modeOptions, // 使用新生成的模式选项
      timerTasks: playerData.timerTasks, // 使用修复后的行程任务
      showFirstVisitTip: playerData.firstVisit,
      isGroup: isGroup
    };
    this.setData(initialData);

    if (playerData.firstVisit) {
      storageService.setPlayerModeVisited(entityId, isGroup, deviceType)
    }
  },

  onReady() {
    const $t = this;
    if (!this.data.isGroup) {
      wx.$event.on(this.data.device.topicSub, this, (obj) => {
        if (obj.type == "chgAutoRun") {
          $t.switchChangeResult(1);
        } else if (obj.type == "syncDataUp") {
          $t.handleSyncToDeviceDialogResult(1);
        }
      })
    } else {
      this.data.devices.forEach(device => {
        wx.$event.on(device.topicSub, $t, (obj) => {
          if (obj.type == "chgAutoRun") {
            $t.switchChangeResultGroup(1);
          } else if (obj.type == "syncDataUp") {
            $t.handleSyncToDeviceDialogResultGroup(1);
          }
        })
      })
    }
  },

  updateLightFromSlider: function (e) {
    const {
      type,
      value,
      pwmValue
    } = e.detail;
    const presetIndex = this.data.presets.findIndex(p => p.selected);
    if (presetIndex === -1) {
      console.error('未找到选中的预设!');
      return;
    }
    if (!this.data.isManualMode) {
      // 创建预设的副本用于更新
      const updatedPresets = [...this.data.presets];
      this.setData({
        presets: updatedPresets
      })
      wx.showModal({
        title: '提示',
        content: '行程模式下，无法调整',
        showCancel: false,
      })
      return
    }

    // 创建预设的副本用于更新
    const updatedPresets = [...this.data.presets];
    const selectedPreset = {
      ...updatedPresets[presetIndex]
    };
    selectedPreset.channels.forEach(ele => {
      if (ele.n == type) {
        ele.v = value
      }
    })

    // 更新到预设数组
    updatedPresets[presetIndex] = selectedPreset;
    // 设置更新后的数据
    this.setData({
      presets: updatedPresets
    }, () => {
      // 手动模式，在数据更新完成后发送MQTT消息
      console.log('手动模式下滑块值更新，立即发送MQTT消息');
      appInstance.sendMtMsg(this.data.device.topicSend, "chgVal", {
        "n": type,
        "v": value
      });
    });

    // 保存玩家模式数据
    console.log('正在保存玩家模式数据...');
    this.savePlayerData();
    console.log('玩家模式数据保存完成');

    this.saveLastManualVal(selectedPreset.channels)
  },

  updateLightFromSlidering: function (e) {
    const {
      type,
      value,
      pwmValue
    } = e.detail;
    if (!this.data.isManualMode) {
      return
    }
    const presetIndex = this.data.presets.findIndex(p => p.selected);
    if (presetIndex === -1) {
      return;
    }

    // 创建预设的副本用于更新
    const updatedPresets = [...this.data.presets];
    const selectedPreset = {
      ...updatedPresets[presetIndex]
    };
    selectedPreset.channels.forEach(ele => {
      if (ele.n == type) {
        ele.v = value
      }
    })
    // 更新到预设数组
    updatedPresets[presetIndex] = selectedPreset;
    // 设置更新后的数据
    this.setData({
      presets: updatedPresets
    });
  },

  // 选择预设模式
  selectPreset: function (e) {
    const presetId = e.currentTarget.dataset.id;
    const deviceType = this.data.device.deviceType;

    // 更新所有预设的选中状态，同时确保禁用通道的值为0
    const presets = this.data.presets.map(preset => {
      const isSelected = preset.id === presetId;
      const updatedPreset = {
        ...preset,
        selected: isSelected
      };

      return updatedPreset;
    });

    // 获取选中的预设
    const selectedPreset = presets.find(preset => preset.selected);
    if (!selectedPreset) return;

    // 更新预设数据
    this.setData({
      presets
    });

    if (this.data.isManualMode) {
      // 发送MQTT消息
      this.sendRgbwMqttMessage(selectedPreset, deviceType);
    }

    // 保存数据
    this.savePlayerData();
    this.saveLastManualVal(selectedPreset.channels)
  },

  /**
   * 初始化预设数据
   */
  initializePresets: function (storagePresets) {
    // 如果没有存储的预设数据，返回默认预设
    if (!storagePresets || !Array.isArray(storagePresets) || storagePresets.length === 0) {
      console.log('未找到存储的预设数据，使用默认预设');
      let channels = storageService.getDeviceChannels(this.data.did)
      let presets = []
      for (var i = 0; i < 15; i++) {
        let obj = {
          id: (i + 1),
          name: '自定义' + (i + 1),
          selected: i == 0
        }
        let newChannels = JSON.parse(JSON.stringify(channels))
        newChannels.forEach(ele => {
          ele.v = 0
        })
        obj.channels = newChannels
        presets.push(obj)
      }
      return presets;
    } else {
      return storagePresets
    }
  },

  /**
   * 获取玩家模式选项
   * @returns {Array} 玩家模式选项列表
   */
  getPlayerModeOptions: function (presets) {
    // 从预设中生成玩家模式选项
    const options = presets.map(preset => ({
      name: preset.name,
      modeCode: `p${preset.id}`,
      modeType: 'player_mode'
    }));
    return options;
  },

  /**
   * 保存玩家模式数据
   */
  savePlayerData: function () {
    try {
      const entityId = this.data.did;
      const isGroup = 0;
      const deviceType = this.data.device.deviceType;

      // 保存玩家模式数据
      const playerModeData = {
        presets: this.data.presets,
        timerTasks: this.data.timerTasks,
      };

      // 使用统一的存储服务保存数据
      storageService.savePlayerModeData(entityId, playerModeData, isGroup, deviceType);

      // 记录日志
      console.log(`保存玩家模式数据成功 (ID: ${entityId}, isGroup: ${isGroup})`);
    } catch (e) {
      console.error('保存玩家模式数据失败:', e);
    }
  },

  /**
   * 发送RGBW MQTT消息
   * @param {Object} preset - 预设数据
   * @param {string} deviceType - 设备类型
   */
  sendRgbwMqttMessage: function (preset, deviceType) {
    if (!preset || !deviceType) {
      console.error('sendRgbwMqttMessage: 缺少必要参数');
      return;
    }
    try {
      const mqttData = []
      preset.channels.forEach(ele => {
        mqttData.push({
          "n": ele.n,
          "v": ele.u == 1 ? ele.v : 0
        })
      })

      // 记录即将发送的MQTT消息内容
      console.log('MQTT消息内容:', JSON.stringify(mqttData));
      if (!this.data.isGroup) {
        appInstance.sendMtMsg(this.data.device.topicSend, "chgValAll1", mqttData);
      } else {
        this.data.devices.forEach(device => {
          appInstance.sendMtMsg(device.topicSend, "chgValAll1", mattData);
        })
      }
    } catch (e) {
      console.error('发送RGBW MQTT消息失败:', e);
    }
  },

  /**
   * 关闭首次访问提示
   */
  closeFirstVisitTip: function () {
    this.setData({
      showFirstVisitTip: false
    });

    // 记录日志
    console.log('已关闭玩家模式首次访问提示');
  },

  /**
   * 处理底部行程设置/手动模式按钮的长按事件
   * 用于切换灯光模式（从手动模式到自动模式，或从自动模式到手动模式）
   */
  handleLongPress: function () {
    const $t = this;
    // 切换灯光模式：从手动到自动，或从自动到手动
    if (this.data.isManualMode) {
      // 切换到自动模式
      storageService.saveLightModeState(this.data.did, 'auto');
      // 更新UI状态
      this.setData({
        isManualMode: false
      });
      this.showToast('已切换为自动模式', 'success')
    } else {
      // 当前是自动模式，切换到手动模式
      this.data.switchType = 2
      wx.showLoading({
        title: 'Loading......',
        mask: true,
        success: function () {
          $t.sendSwitchChange()
        }
      });

    }
  },

  /**
   * 处理预设模式的长按事件
   * 用于编辑预设的名称
   * @param {Object} e - 事件对象
   */
  onPresetLongPress: function (e) {
    const presetId = e.currentTarget.dataset.id;
    const presetIndex = this.data.presets.findIndex(preset => preset.id === presetId);

    if (presetIndex === -1) {
      console.error(`未找到ID为 ${presetId} 的预设`);
      return;
    }

    const preset = this.data.presets[presetIndex];
    const currentName = preset.name;

    // 弹出修改名称的对话框
    wx.showModal({
      title: '编辑预设名称',
      content: '',
      editable: true,
      placeholderText: '请输入预设名称',
      value: currentName, // 使用value属性设置初始值，这是微信小程序官方推荐的方式
      success: (res) => {
        if (res.confirm && res.content.trim()) {
          // 更新预设名称
          const updatedPresets = [...this.data.presets];
          updatedPresets[presetIndex].name = res.content.trim();

          // 更新UI
          this.setData({
            presets: updatedPresets
          });

          // 保存更新后的数据
          this.savePlayerData();
          this.showToast('预设已更新', 'success')
        }
      }
    });
  },

  /**
   * 处理底部行程设置/手动模式按钮的点击事件
   * 打开行程设置弹窗
   */
  goToSchedule: function () {
    if (this.data.isManualMode) {
      return
    }
    this.setData({
      showTimerPopup: true
    });
  },

  /**
   * 关闭行程设置弹窗
   */
  closePopup: function () {
    this.setData({
      showTimerPopup: false
    });
  },

  /**
   * 阻止遮罩层的触摸穿透
   */
  preventTouchMove: function () {
    return false; // 阻止事件冒泡
  },

  /**
   * 确认时间冲突弹窗
   */
  confirmTimeConflict: function () {
    this.setData({
      showTimeConflictConfirm: false
    });
  },

  /**
   * 确认跨0点设置
   */
  confirmCrossZero: function () {
    const {
      crossZeroTaskIndex,
      crossZeroNewTime,
      crossZeroNewEndTime
    } = this.data;

    if (crossZeroTaskIndex === undefined || !crossZeroNewTime || !crossZeroNewEndTime) {
      console.error('confirmCrossZero: 缺少必要参数');
      this.setData({
        showCrossZeroConfirm: false
      });
      return;
    }

    // 更新任务时间并启用跨0点模式
    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[crossZeroTaskIndex].time = crossZeroNewTime;
    updatedTasks[crossZeroTaskIndex].endTime = crossZeroNewEndTime;
    updatedTasks[crossZeroTaskIndex].crossZeroMode = true;

    this.setData({
      timerTasks: updatedTasks,
      showCrossZeroConfirm: false,
      crossZeroTaskIndex: undefined,
      crossZeroNewTime: '',
      crossZeroNewEndTime: ''
    });

    // 保存数据
    this.savePlayerData();
  },

  /**
   * 取消跨0点设置
   */
  cancelCrossZero: function () {
    this.setData({
      showCrossZeroConfirm: false,
      crossZeroTaskIndex: undefined,
      crossZeroNewTime: '',
      crossZeroNewEndTime: ''
    });
  },

  /**
   * 取消删除行程任务
   */
  cancelDelete: function () {
    this.setData({
      showDeleteConfirm: false,
      deleteTaskIndex: -1
    });
  },

  /**
   * 确认删除行程任务
   */
  confirmDelete: function () {
    const index = this.data.deleteTaskIndex;
    if (index === -1) {
      this.setData({
        showDeleteConfirm: false
      });
      return;
    }

    // 删除任务
    const updatedTasks = [...this.data.timerTasks];
    updatedTasks.splice(index, 1);

    this.setData({
      timerTasks: updatedTasks,
      showDeleteConfirm: false,
      deleteTaskIndex: -1
    });

    // 保存更新后的数据
    this.savePlayerData();
    this.showToast('已删除行程', 'success')
  },

  /**
   * 显示删除确认弹窗
   */
  deleteTimerTask: function (e) {
    const index = e.currentTarget.dataset.index;
    if (!this.data.isManualMode && this.data.timerTasks[index].enabled) {
      wx.showModal({
        title: '提示',
        content: '行程模式，当前行程启用状态下，无法删除。',
        showCancel: false,
      })
      return
    }

    this.setData({
      showDeleteConfirm: true,
      deleteTaskIndex: index
    });
  },

  /**
   * 添加空行程任务
   */
  addEmptyTimerTask: function () {
    // 创建新的行程任务
    const newTask = {
      id: Date.now().toString(), // 使用时间戳作为唯一ID
      time: '--:--', // 默认时间为未设置
      endTime: '--:--', // 默认结束时间为未设置
      mode: 'p1', // 默认使用第一个预设
      displayMode: this.data.presets[0]?.name || '自定义1', // 显示名称
      modeType: 'player_mode', // 类型为玩家模式
      brightness: 100, // 默认亮度为100%
      fadeIn: 10, // 默认缓亮为0分钟
      fadeOut: 10, // 默认缓暗为0分钟
      enabled: false, // 默认未启用
      editing: true, // 默认进入编辑状态
      crossZeroMode: false, // 默认不启用跨0点模式
      modeIndex: modeNum, // 默认使用第一个模式
    };

    // 更新任务列表
    const updatedTasks = [...this.data.timerTasks, newTask];

    this.setData({
      timerTasks: updatedTasks
    });

    // 保存更新后的数据
    this.savePlayerData();
  },

  /**
   * 切换行程任务启用状态
   */
  toggleTaskEnabled: function (e) {
    const index = e.currentTarget.dataset.index;
    const entityId = this.data.did;
    const isGroup = this.data.isGroup;
    const deviceType = this.data.device.deviceType;

    const updatedTasks = [...this.data.timerTasks];
    const enabled = !updatedTasks[index].enabled;

    this.data.tmpIndex = index
    this.data.tmpEnabled = enabled

    if (enabled) {
      // 检查时间是否有效
      if (updatedTasks[index].time === '--:--' || updatedTasks[index].endTime === '--:--') {
        this.showToast('请先设置有效时间')
        // 恢复开关状态
        updatedTasks[index].enabled = false;
        this.setData({
          timerTasks: updatedTasks,
        });
        return;
      }
      // 启用任务时，检查是否有冲突
      if (lightCommonService.checkTimeOverlap(this.data.timerTasks, index)) {
        wx.showModal({
          title: '行程时间冲突',
          content: '此行程与其他已启用的行程时间存在冲突，请先调整时间。',
          showCancel: false,
        });

        // 恢复开关状态
        updatedTasks[index].enabled = false;
        this.setData({
          timerTasks: updatedTasks,
        });
        return;
      }
      // 检查高阶模式是否有启用的曲线
      if (lightCommonService.checkAdvancedEnabled(entityId, isGroup, deviceType)) {
        // 恢复开关状态
        updatedTasks[index].enabled = false;
        this.setData({
          timerTasks: updatedTasks,
        });
        return;
      }
      this.data.switchType = 3
      this.sendNewSchedule2Device(1)
    } else {
      // 检查是否还有其他启用的行程卡片
      const hasOtherEnabledTasks = updatedTasks.some((task, i) => i !== index && task.enabled);
      // 如果关闭卡片且没有其他启用的卡片，重置控制条
      if (!hasOtherEnabledTasks) {
        this.data.switchType = 5
        const $t = this
        wx.showLoading({
          title: 'Loading......',
          mask: true,
          success: function () {
            $t.sendSwitchChange()
          }
        });
      } else {
        this.data.switchType = 4
        this.sendNewSchedule2Device(1)
      }
    }
  },

  /**
   * 切换行程任务编辑状态
   */
  toggleEditMode: function (e) {
    const index = e.currentTarget.dataset.index;
    const updatedTasks = [...this.data.timerTasks];
    const currentlyEditing = updatedTasks[index].editing;

    // 如果当前正在编辑，则保存编辑结果
    if (currentlyEditing) {
      // 检查时间是否有效
      if (updatedTasks[index].time === '--:--' || updatedTasks[index].endTime === '--:--') {
        this.showToast('请设置有效时间')
        return;
      }
    } else {
      if (!this.data.isManualMode && updatedTasks[index].enabled) {
        wx.showModal({
          title: '提示',
          content: '行程模式，当前行程启用状态下，无法编辑。',
          showCancel: false,
        })
        return
      }
    }


    // 切换编辑状态
    updatedTasks[index].editing = !currentlyEditing;

    this.setData({
      timerTasks: updatedTasks
    });

    // 如果切换到非编辑状态，保存数据
    if (currentlyEditing) {
      this.savePlayerData();
    }
  },

  /**
   * 处理开始时间修改
   */
  onEditTimeChange: function (e) {
    const index = e.currentTarget.dataset.index;
    const timeValue = e.detail.value;

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].time = timeValue;

    // 检查是否有时间冲突
    if (updatedTasks[index].endTime !== '--:--') {
      // 当设置结束时间早于开始时间时（非跨0点）
      const startMinutes = lightCommonService.timeToMinutes(timeValue);
      const endMinutes = lightCommonService.timeToMinutes(updatedTasks[index].endTime);

      if (startMinutes > endMinutes && !updatedTasks[index].crossZeroMode) {
        // 提示用户可能需要启用跨0点
        this.setData({
          showCrossZeroConfirm: true,
          crossZeroTaskIndex: index,
          crossZeroNewTime: timeValue,
          crossZeroNewEndTime: updatedTasks[index].endTime
        });
        return;
      }
    }

    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 处理结束时间修改
   */
  onEditEndTimeChange: function (e) {
    const index = e.currentTarget.dataset.index;
    const endTimeValue = e.detail.value;

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].endTime = endTimeValue;

    // 检查是否有时间冲突
    if (updatedTasks[index].time !== '--:--') {
      // 当设置结束时间早于开始时间时（非跨0点）
      const startMinutes = lightCommonService.timeToMinutes(updatedTasks[index].time);
      const endMinutes = lightCommonService.timeToMinutes(endTimeValue);

      if (startMinutes > endMinutes && !updatedTasks[index].crossZeroMode) {
        // 提示用户可能需要启用跨0点
        this.setData({
          showCrossZeroConfirm: true,
          crossZeroTaskIndex: index,
          crossZeroNewTime: updatedTasks[index].time,
          crossZeroNewEndTime: endTimeValue
        });
        return;
      }
      if (updatedTasks[index].crossZeroMode && startMinutes < endMinutes) {
        updatedTasks[index].crossZeroMode = false
      }
    }


    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 处理模式修改
   */
  onEditModeChange: function (e) {
    console.log(e)
    const index = e.currentTarget.dataset.index;
    const modeIndex = parseInt(e.detail.value);

    const updatedTasks = [...this.data.timerTasks];
    const allModes = this.data.modeOptions;

    // 确保模式索引有效
    if (modeIndex >= 0 && modeIndex < allModes.length) {
      updatedTasks[index].displayMode = allModes[modeIndex];
      updatedTasks[index].modeIndex = modeIndex;
      updatedTasks[index].mode = `p${modeIndex+1}`;
    }

    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 切换跨0点模式
   */
  toggleCrossZeroMode: function (e) {
    //禁用手动切换跨0点，根据时间大小自动判断
  },

  /**
   * 处理亮度修改
   */
  onEditBrightnessChange: function (e) {
    const index = e.currentTarget.dataset.index;
    let value = parseInt(e.detail.value);

    // 确保值为非负数
    if (isNaN(value) || value < 0) {
      value = 0
    }
    if (value > 100) {
      value = 100
    }

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].brightness = value;

    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 亮度输入框获取焦点
   */
  onBrightnessFocus: function (e) {
    // 可以在这里添加亮度输入框获取焦点时的逻辑
  },

  /**
   * 亮度输入框失去焦点
   */
  onBrightnessBlur: function (e) {
    const index = e.currentTarget.dataset.index;
    let value = parseInt(e.detail.value);

    // 确保值为非负数
    if (isNaN(value) || value < 0) {
      value = 0
    }
    if (value > 100) {
      value = 100
    }

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].brightness = value;

    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 处理淡入时间修改
   */
  onEditFadeInChange: function (e) {
    const index = e.currentTarget.dataset.index;
    let value = parseInt(e.detail.value);

    // 确保值为非负数
    if (isNaN(value) || value < 0) value = 0;

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].fadeIn = value;

    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 淡入输入框获取焦点
   */
  onFadeInFocus: function (e) {
    // 可以在这里添加淡入输入框获取焦点时的逻辑
  },

  /**
   * 淡入输入框失去焦点
   */
  onFadeInBlur: function (e) {
    const index = e.currentTarget.dataset.index;
    let value = parseInt(e.detail.value);

    // 确保值为非负数
    if (isNaN(value) || value < 0) value = 0;

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].fadeIn = value;

    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 处理淡出时间修改
   */
  onEditFadeOutChange: function (e) {
    const index = e.currentTarget.dataset.index;
    let value = parseInt(e.detail.value);

    // 确保值为非负数
    if (isNaN(value) || value < 0) value = 0;

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].fadeOut = value;

    this.setData({
      timerTasks: updatedTasks
    });
  },

  /**
   * 淡出输入框获取焦点
   */
  onFadeOutFocus: function (e) {
    // 可以在这里添加淡出输入框获取焦点时的逻辑
  },

  /**
   * 淡出输入框失去焦点
   */
  onFadeOutBlur: function (e) {
    const index = e.currentTarget.dataset.index;
    let value = parseInt(e.detail.value);

    // 确保值为非负数
    if (isNaN(value) || value < 0) value = 0;

    const updatedTasks = [...this.data.timerTasks];
    updatedTasks[index].fadeOut = value;

    this.setData({
      timerTasks: updatedTasks
    });
  },

  // 处理通道布局变化
  onChannelLayoutChanged(e) {
    // 如果页面当前不可见，则不处理此事件
    if (!this._isPageShowing) {
      return;
    }

    // 防止处理过程中触发的重复事件导致递归更新
    if (this._updatingChannelLayout) {
      return;
    }

    this._updatingChannelLayout = true;

    try {
      console.log('通道布局已变更：', e.detail);
      const {
        enabledChannels,
        spacing
      } = e.detail;

      // 根据启用的通道数量设置样式类
      let containerClass = '';
      if (enabledChannels <= 3) {
        containerClass = 'few-channels';
      } else if (enabledChannels <= 6) {
        containerClass = 'medium-channels';
      } else {
        containerClass = 'many-channels';
      }

      // 使用setTimeout延迟更新，避免在当前更新周期内触发另一个更新
      setTimeout(() => {
        this.setData({
          sliderContainerClass: containerClass,
          forceRefresh: !this.data.forceRefresh // 切换强制刷新标志，确保UI更新
        });

        // 清除更新标志
        this._updatingChannelLayout = false;
      }, 50);
    } catch (error) {
      console.error('处理通道布局变化时出错：', error);
      this._updatingChannelLayout = false;
    }
  },






  sendSwitchChange() {
    const $t = this
    if (!$t.data.isGroup) {
      appInstance.sendMtMsg($t.data.device.topicSend, "chgAutoRun", 0)
      $t.data.timeoutObj = setTimeout(function () {
        $t.switchChangeResult(0);
      }, 5000);
    } else {
      $t.data.syncNum = 0
      $t.data.devices.forEach(device => {
        appInstance.sendMtMsg(device.topicSend, "chgAutoRun", 0);
      })
      $t.data.timeoutObj = setTimeout(function () {
        $t.switchChangeResultGroup(0);
      }, 8000);
    }
  },

  switchChangeResult(succ) {
    //两种情况调用：2自动切手动、5最后一个启用的行程被禁用
    wx.hideLoading();
    if (succ == 0) {
      //最后一个启用的行程被禁用
      if (this.data.switchType == 5) {
        wx.showModal({
          title: '提示',
          content: '禁用异常，请求响应超时...',
          showCancel: false,
        })
      } else {
        wx.showModal({
          title: '提示',
          content: '切换模式异常，请求响应超时...',
          showCancel: false,
        })
      }

    } else {
      clearTimeout(this.data.timeoutObj);
      let entityId = this.data.did
      if (this.data.switchType == 2) {
        //禁用所有task
        const updatedTasks = [...this.data.timerTasks]
        updatedTasks.forEach(task => {
          task.enabled = false
        })
        this.setData({
          timerTasks: updatedTasks,
        })
        //禁用高阶模式
        advancedModeService.disableAdvancedCurves(entityId)
        storageService.saveLightModeState(entityId, 'manual');
        this.setData({
          isManualMode: true
        });
        this.showToast('已切换为手动模式', 'success')
        const selectedPreset = this.data.presets.find(p => p.selected);
        if (selectedPreset) {
          this.sendRgbwMqttMessage(selectedPreset, this.data.device.deviceType);
        }
      } else if (this.data.switchType == 5) { //最后一个启用的行程被禁用
        const updatedTasks = [...this.data.timerTasks]
        updatedTasks[this.data.tmpIndex].enabled = this.data.tmpEnabled
        this.setData({
          timerTasks: updatedTasks,
        })
        const selectedPreset = this.data.presets[0]
        const mqttData = []
        selectedPreset.channels.forEach(ele => {
          mqttData.push({
            "n": ele.n,
            "v": 0
          })
        })
        // 记录即将发送的MQTT消息内容
        console.log('MQTT消息内容:', JSON.stringify(mqttData));
        if (!this.data.isGroup) {
          appInstance.sendMtMsg(this.data.device.topicSend, "chgValAll1", mqttData);
        } else {
          this.data.devices.forEach(device => {
            appInstance.sendMtMsg(device.topicSend, "chgValAll1", mattData);
          })
        }
      }
      // 保存更新后的数据
      this.savePlayerData()
      storageService.removeScheduleInfo(this.data.did)
      const pages = getCurrentPages()
      pages[0].changeStartEndTimeById(this.data.did, null)
    }
  },
  switchChangeResultGroup(succ) {
    if (succ == 1) {
      this.data.syncNum++
    }
    if (this.data.syncNum >= this.data.devices.length) {
      this.switchChangeResult(1)
      return
    }
    if (succ == 0) {
      if (this.data.syncNum == 0) {
        this.switchChangeResult(0)
      } else {
        wx.hideLoading()
        //最后一个启用的行程被禁用
        if (this.data.switchType == 5) {
          wx.showModal({
            title: '提示',
            content: '禁用异常，部分设备失败，请检查设备状态并重新操作。成功' + this.data.syncNum + '台，失败' + (this.data.devices.length - this.data.syncNum) + '台',
            showCancel: false,
          })
        } else {
          wx.showModal({
            title: '提示',
            content: '切换模式异常，部分设备失败，请检查设备状态并重新操作。成功' + this.data.syncNum + '台，失败' + (this.data.devices.length - this.data.syncNum) + '台',
            showCancel: false,
          })
        }
      }
    }

  },

  sendNewSchedule2Device(needUpdate) {
    console.log(JSON.stringify(this.data.timerTasks))
    const updatedTasks = [...this.data.timerTasks]
    if (needUpdate == 1) {
      updatedTasks[this.data.tmpIndex].enabled = this.data.tmpEnabled
    }

    const newTasks = []
    for (var i = 0; i < updatedTasks.length; i++) {
      var curTimeTask = updatedTasks[i]
      if (!curTimeTask.enabled) {
        continue
      }
      // 当前任务时间
      const currentStartTime = lightCommonService.timeToMinutes(curTimeTask.time);
      const currentEndTime = lightCommonService.timeToMinutes(curTimeTask.endTime);
      console.log(`任务时间：${currentStartTime}-${currentEndTime}`)
      if (currentStartTime < currentEndTime) { //TODO保存时候校验时间是否合理end-start-fadeIn-fadeOut>0
        curTimeTask.tStart = currentStartTime
        curTimeTask.tEnd = currentEndTime
        newTasks.push(curTimeTask)
      } else {
        const newTask1 = JSON.parse(JSON.stringify(curTimeTask))
        newTask1.tStart = 0
        newTask1.tEnd = currentEndTime
        newTask1.eZero = 1
        newTasks.push(newTask1)
        const newTask2 = JSON.parse(JSON.stringify(curTimeTask))
        newTask2.tStart = currentStartTime
        newTask2.tEnd = 23 * 60 + 59
        newTask2.sZero = 1
        newTasks.push(newTask2)
      }
    }
    newTasks.sort((a, b) => a.time - b.time);
    console.log(newTasks)

    const tlsArr = []
    for (var j = 0; j < this.data.presets[0].channels.length; j++) {
      tlsArr.push([])
    }
    for (var i = 0; i < newTasks.length; i++) {
      let tmin = newTasks[i].tStart % 60
      let thour = (newTasks[i].tStart - tmin) / 60
      let emin = newTasks[i].tEnd % 60
      let ehour = (newTasks[i].tEnd - emin) / 60
      let fadeIn = newTasks[i].fadeIn
      let fadeOut = newTasks[i].fadeOut
      if (fadeIn <= 0) {
        fadeIn = 1
      }
      if (fadeOut <= 0) {
        fadeOut = 1
      }
      let t_tmin = (newTasks[i].tStart + fadeIn) % 60
      let t_thour = (newTasks[i].tStart + fadeIn - t_tmin) / 60
      let t_emin = (newTasks[i].tEnd - fadeOut) % 60
      let t_ehour = (newTasks[i].tEnd - fadeOut - t_emin) / 60
      console.log(t_tmin + ":" + t_thour + ":" + t_emin + ":" + t_ehour)

      let valArr = []
      if (newTasks[i].modeIndex < modeNum) {
        valArr = shortcutModeService.getValsByIdx(newTasks[i].modeIndex, newTasks[i].brightness, this.data.device.deviceType)
      } else {
        valArr = playerModeService.getValsByIdx(this.data.did, newTasks[i].modeIndex - modeNum, newTasks[i].brightness)
      }

      for (var j = 0; j < valArr.length; j++) {
        let arr = tlsArr[j]
        let val = valArr[j]
        if (newTasks[i].eZero && newTasks[i].eZero == 1) {
          arr.push([0, val])
        } else {
          arr.push([thour * 10000 + tmin * 100, 0])
          arr.push([t_thour * 10000 + t_tmin * 100, val])
        }
        if (newTasks[i].sZero && newTasks[i].sZero == 1) {
          arr.push([23 * 10000 + 59 * 100 + 59, val])
        } else {
          arr.push([t_ehour * 10000 + t_emin * 100, val])
          arr.push([ehour * 10000 + emin * 100, 0])
        }
      }
    }
    const mattData = {
      tls: [tlsArr],
      w: [0, 0, 0, 0, 0, 0, 0]
    }
    console.log(`发送行程模式MQTT消息: ${JSON.stringify(mattData)}`)

    const $t = this;
    wx.showLoading({
      title: 'Loading......',
      mask: true,
      success: function () {
        $t.data.mqttData = mattData;
        $t.sendSyncToDeviceDialog(mattData)
      }
    })
  },

  sendSyncToDeviceDialog(mattData) {
    const $t = this
    if (!$t.data.isGroup) {
      appInstance.sendMtMsg($t.data.device.topicSend, "syncDataUp", mattData)
      $t.data.timeoutObj = setTimeout(function () {
        $t.handleSyncToDeviceDialogResult(0);
      }, 5000);
    } else {
      $t.data.syncNum = 0
      $t.data.devices.forEach(device => {
        appInstance.sendMtMsg(device.topicSend, "syncDataUp", mattData);
      })
      $t.data.timeoutObj = setTimeout(function () {
        $t.handleSyncToDeviceDialogResultGroup(0);
      }, 8000);
    }
  },
  handleSyncToDeviceDialogResult(succ) {
    //两种情况下调用：3启用、4禁用
    wx.hideLoading();
    if (succ == 0) {
      wx.showModal({
        title: '提示',
        content: '启用/禁用异常，请求响应超时...',
        showCancel: false,
      })
      const updatedTasks = [...this.data.timerTasks]
      updatedTasks[this.data.tmpIndex].enabled = !this.data.tmpEnabled
      this.setData({
        timerTasks: updatedTasks,
      })
    } else {
      clearTimeout(this.data.timeoutObj);
      //3启用、4禁用
      const updatedTasks = [...this.data.timerTasks];
      updatedTasks[this.data.tmpIndex].enabled = this.data.tmpEnabled;
      this.setData({
        timerTasks: updatedTasks,
      });

      // 保存更新后的数据
      this.savePlayerData()
      const pages = getCurrentPages()
      storageService.saveScheduleInfo(this.data.did, this.data.mqttData)
      pages[0].changeStartEndTimeById(this.data.did, this.data.mqttData)
      this.data.mqttData = null;
    }
  },

  handleSyncToDeviceDialogResultGroup(succ) {
    if (succ == 1) {
      this.data.syncNum++
    }
    if (this.data.syncNum >= this.data.devices.length) {
      this.handleSyncToDeviceDialogResult(1)
      return
    }
    if (succ == 0) {
      if (this.data.syncNum == 0) {
        this.handleSyncToDeviceDialogResult(0)
      } else {
        wx.hideLoading()
        wx.showModal({
          title: '提示',
          content: '启用/禁用异常，部分设备失败，请检查设备状态或重新同步，成功率' + (this.data.syncNum * 100 / this.data.devices.length).toFixed(2) + "%！",
          showCancel: false,
        })
        const updatedTasks = [...this.data.timerTasks]
        updatedTasks[this.data.tmpIndex].enabled = !this.data.tmpEnabled
        this.setData({
          timerTasks: updatedTasks,
        })
      }
    }

  },

  saveLastManualVal(channels) {
    if (!channels || !Array.isArray(channels)) {
      return
    }
    const arr = []
    channels.forEach(ele => {
      arr.push({
        n: ele.n,
        v: ele.u == 1 ? ele.v : 0
      })
    })
    storageService.saveLastManualVal(this.data.did, arr)
  },


  showToast(msg, icon = 'none', duration = 1500) {
    wx.showToast({
      title: msg,
      icon: icon,
      duration: duration
    })
  },

  // 应用页面卸载前刷新所有待更新数据
  onUnload: function () {
    const $t = this
    if (!this.data.isGroup) {
      wx.$event.remove(this.data.device.topicSub, this)
    } else {
      this.data.devices.forEach(device => {
        wx.$event.remove(device.topicSub, $t)
      })
    }
  },

})